// 引入数据模型
const { RaceModel, UserModel, DataValidator } = require('../../utils/dataModels.js')

Page({
  data: {
    menuPosition: wx.getMenuButtonBoundingClientRect(),
    menuItems: [
      {
        key: 1,
        title: "双打"
      },
      {
        key: 2,
        title: "单打"
      }
    ],
    selectedItemIndex: 1,
    tipShow: false,
    title: "",
    desc: "",
    url: "",
    isPreview: false,
    raceList: [],        // 比赛列表（本地存储）
    signupList: [],      // 报名列表（本地存储）
    userInfo: null,
    isCreating: false,
    storageInfo: null,   // 存储信息
  },
  
  async onLoad() {
    try {
      wx.showLoading({ title: '加载中...' });
      
      // 1. 初始化默认数据
      this.initDefaultData();
      
      // 2. 从本地存储加载数据
      await this.loadLocalData();
      
      // 3. 获取存储使用情况
      let storageInfo = {};
      try {
        storageInfo = wx.getStorageInfoSync();
      } catch (error) {
        console.error('获取存储信息失败:', error);
        storageInfo = { currentSize: 0, limitSize: 10240 };
      }
      this.setData({ storageInfo });
      
      wx.hideLoading();
      
      // 4. 显示数据统计
      this.showDataStats();
      
    } catch (error) {
      console.error('[Index] 页面加载失败:', error);
      wx.hideLoading();
      wx.showToast({ title: '加载失败', icon: 'none' });
    }
  },
  
  /**
   * 从本地存储加载数据
   */
  async loadLocalData() {
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      // 加载用户信息 - 直接使用 wx.getStorageSync
      const userInfo = wx.getStorageSync('userInfo');
      if (userInfo) {
        this.setData({ userInfo });
        getApp().globalData.userInfo = userInfo;
      }
      
      // 使用 localDataManager 加载比赛列表
      const raceList = localDataManager.getAllRaces();
      this.setData({ raceList });
      
      // 使用 localDataManager 加载报名列表
      const signupList = localDataManager.getAllSignups();
      this.setData({ signupList });
      
      console.log('[Index] 本地数据加载完成:', {
        userInfo: !!userInfo,
        raceCount: raceList.length,
        signupCount: signupList.length
      });
      
    } catch (error) {
      console.error('[Index] 加载本地数据失败:', error);
    }
  },
  
  /**
   * 初始化默认数据
   */
  initDefaultData() {
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      // 检查是否需要初始化默认数据
      const raceList = localDataManager.getAllRaces();
      const signupList = localDataManager.getAllSignups();
      const settings = wx.getStorageSync('settings');
      
      if (!raceList || raceList.length === 0) {
        // localDataManager 会自动初始化空数组
        console.log('[Index] 初始化比赛列表');
      }
      
      if (!signupList || signupList.length === 0) {
        console.log('[Index] 初始化报名列表');
      }
      
      if (!settings) {
        const defaultSettings = {
          autoBackup: false, // 不自动备份到云端
          theme: 'light',
          language: 'zh-CN',
          notifications: true,
          soundEnabled: true
        };
        wx.setStorageSync('settings', defaultSettings);
        console.log('[Index] 初始化应用设置');
      }
      
    } catch (error) {
      console.error('[Index] 初始化默认数据失败:', error);
    }
  },
  
  /**
   * 显示数据统计
   */
  showDataStats() {
    const { raceList, signupList } = this.data;
    
    // 获取存储信息
    let storageInfo = {};
    try {
      storageInfo = wx.getStorageInfoSync();
    } catch (error) {
      console.error('获取存储信息失败:', error);
      storageInfo = { currentSize: 0, limitSize: 10240 };
    }
    
    const usagePercent = ((storageInfo.currentSize || 0) / (storageInfo.limitSize || 10240)) * 100;
    
    console.log('[Index] 数据统计:', {
      比赛数量: raceList.length,
      报名数量: signupList.length,
      存储使用: `${usagePercent.toFixed(1)}%`,
      存储大小: `${(storageInfo.currentSize / 1024).toFixed(2)}KB / ${(storageInfo.limitSize / 1024).toFixed(2)}KB`
    });
    
    // 如果存储使用超过80%，提示清理
    if (usagePercent > 80) {
      console.warn('[Index] 存储空间使用率较高，建议清理过期数据');
      wx.showToast({ 
        title: '存储空间不足，建议清理数据', 
        icon: 'none',
        duration: 3000
      });
    }
  },
  onChangeTab(e) {
    const {key}=e.target.dataset
    this.setData({
      selectedItemIndex:key
    })
  },
  onOpenTipsModal(){
    this.setData({
      tipShow:true
    })
  },
  onRaceCardTap(e) {
    const type = e.currentTarget.dataset.type;
    if (type === 'round') {
      // 多人轮转赛：先判断是否登录
      const userInfo = getApp().globalData.userInfo;
      if (!userInfo) {
        wx.showToast({ title: '请先登录', icon: 'none' });
        return;
      }
      this.goToRaceEnroll('round');
    } else if (type === 'fixed') {
      // 固搭循环赛：先判断是否登录
      const userInfo = getApp().globalData.userInfo;
      if (!userInfo) {
        wx.showToast({ title: '请先登录', icon: 'none' });
        return;
      }
      this.goToFixedRace('fixed');
    } else if (type === 'single') {
      // 单打循环赛：先判断是否登录
      const userInfo = getApp().globalData.userInfo;
      if (!userInfo) {
        wx.showToast({ title: '请先登录', icon: 'none' });
        return;
      }
      this.goToSinglePlay('single');
    } else if (type === 'double_elimination') {
      // 双打淘汰赛：先判断是否登录
      const userInfo = getApp().globalData.userInfo;
      if (!userInfo) {
        wx.showToast({ title: '请先登录', icon: 'none' });
        return;
      }
      this.goToDoubleElimination('double_elimination');
    } else {
      wx.showToast({ title: '敬请期待', icon: 'none' });
    }
  },
  onTabBarTap(e) {
    const tab = Number(e.currentTarget.dataset.tab);
    if (tab === 2) {
      wx.navigateTo({ url: '/pages/me/me' });
      return;
    }
    this.setData({ selectedTab: tab });
  },
  onGetUserProfile() {
    wx.getUserProfile({
      desc: '用于完善会员资料',
      success: res => {
        this.setData({ userInfo: res.userInfo });
      },
      fail: () => {
        wx.showToast({ title: '微信授权失败', icon: 'none' });
      }
    });
  },
  onLogout() {
    this.setData({ userInfo: null });
  },
  /**
   * 创建新比赛（使用本地存储）
   */
  goToRaceEnroll(type) {
    if (this.data.isCreating) return; // 防止重复点击
    
    const userInfo = getApp().globalData.userInfo;
    if (!userInfo) {
      wx.showToast({ title: '请先登录', icon: 'none' });
      return;
    }
    
    this.setData({ isCreating: true });
    
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      // 1. 创建新比赛数据
      const now = new Date();
      const mm = (now.getMonth() + 1).toString().padStart(2, '0');
      const dd = now.getDate().toString().padStart(2, '0');
      const defaultTitle = `${type === 'round' ? '多人轮转赛' : '固搭循环赛'} | ${mm}-${dd}发布`;
      
             // 创建新比赛对象，复制RaceModel的所有属性
       const newRace = {};
       for (let key in RaceModel) {
         if (RaceModel.hasOwnProperty(key)) {
           newRace[key] = RaceModel[key];
         }
       }
       
       // 设置新比赛的属性
       newRace.id = this.generateId();
       newRace._id = this.generateId(); // 同时设置 _id 字段
       newRace.title = defaultTitle;
       newRace.dateStr = '';
       newRace.creator = userInfo;
       newRace.createdAt = now.toISOString();
       newRace.status = '报名中';
       newRace.type = type;
       newRace.courtCount = 1;
       newRace.maxPlayers = type === 'round' ? 8 : 12; // 轮转赛默认8人，固搭赛默认12人
       newRace.signupList = [];
       newRace.gameList = [];
      
      // 2. 使用 localDataManager 保存到本地存储
      localDataManager.saveRace(newRace);
      
      // 3. 更新页面数据
      this.setData({ 
        isCreating: false 
      });
      
      // 4. 跳转到比赛详情页
      wx.navigateTo({
        url: `/pages/raceEnroll/raceEnroll?id=${newRace.id}`
      });
      
      wx.showToast({ title: '创建成功', icon: 'success' });
      
    } catch (error) {
      console.error('[Index] 创建比赛失败:', error);
      wx.showToast({ title: '创建失败', icon: 'none' });
      this.setData({ isCreating: false });
    }
  },

  /**
   * 创建固搭循环赛
   */
  goToFixedRace(type) {
    if (this.data.isCreating) return; // 防止重复点击
    
    const userInfo = getApp().globalData.userInfo;
    if (!userInfo) {
      wx.showToast({ title: '请先登录', icon: 'none' });
      return;
    }
    
    this.setData({ isCreating: true });
    
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      // 1. 创建新比赛数据
      const now = new Date();
      const mm = (now.getMonth() + 1).toString().padStart(2, '0');
      const dd = now.getDate().toString().padStart(2, '0');
      const defaultTitle = `固搭循环赛 | ${mm}-${dd}发布`;
      
      // 创建新比赛对象，复制RaceModel的所有属性
      const newRace = {};
      for (let key in RaceModel) {
        if (RaceModel.hasOwnProperty(key)) {
          newRace[key] = RaceModel[key];
        }
      }
      
      // 设置新比赛的属性
      newRace.id = this.generateId();
      newRace._id = this.generateId(); // 同时设置 _id 字段
      newRace.title = defaultTitle;
      newRace.dateStr = '';
      newRace.creator = userInfo;
      newRace.createdAt = now.toISOString();
      newRace.status = '报名中';
      newRace.type = type;
      newRace.courtCount = 1;
      newRace.maxPlayers = 8; // 固搭赛默认8人（导入和生成对阵时最大仍为28人）
      newRace.signupList = [];
      newRace.gameList = [];
      
      // 2. 使用 localDataManager 保存到本地存储
      localDataManager.saveRace(newRace);
      
      // 3. 更新页面数据
      this.setData({ 
        isCreating: false 
      });
      
      // 4. 跳转到固搭循环赛页面
      wx.navigateTo({
        url: `/pages/fixedRace/fixedRace?id=${newRace.id}`
      });
      
      wx.showToast({ title: '创建成功', icon: 'success' });
      
    } catch (error) {
      console.error('[Index] 创建固搭循环赛失败:', error);
      wx.showToast({ title: '创建失败', icon: 'none' });
      this.setData({ isCreating: false });
    }
    },

  /**
   * 创建单打循环赛
   */
  goToSinglePlay(type) {
    if (this.data.isCreating) return; // 防止重复点击
    
    const userInfo = getApp().globalData.userInfo;
    if (!userInfo) {
      wx.showToast({ title: '请先登录', icon: 'none' });
      return;
    }
    
    this.setData({ isCreating: true });
    
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      // 1. 创建新比赛数据
      const now = new Date();
      const mm = (now.getMonth() + 1).toString().padStart(2, '0');
      const dd = now.getDate().toString().padStart(2, '0');
      const defaultTitle = `单打循环赛 | ${mm}-${dd}发布`;
      
      // 创建新比赛对象，复制RaceModel的所有属性
      const newRace = {};
      for (let key in RaceModel) {
        if (RaceModel.hasOwnProperty(key)) {
          newRace[key] = RaceModel[key];
        }
      }
      
      // 设置新比赛的属性
      newRace.id = this.generateId();
      newRace._id = this.generateId(); // 同时设置 _id 字段
      newRace.title = defaultTitle;
      newRace.dateStr = '';
      newRace.creator = userInfo;
      newRace.createdAt = now.toISOString();
      newRace.status = '报名中';
      newRace.type = type;
      newRace.courtCount = 1;
      newRace.maxPlayers = 6; // 单打赛默认6人
      newRace.signupList = [];
      newRace.gameList = [];
      
      // 2. 使用 localDataManager 保存到本地存储
      localDataManager.saveRace(newRace);
      
      // 3. 更新页面数据
      this.setData({ 
        isCreating: false 
      });
      
      // 4. 跳转到单打循环赛页面
      wx.navigateTo({
        url: `/pages/singlePlay/singlePlay?id=${newRace.id}`
      });
      
      wx.showToast({ title: '创建成功', icon: 'success' });
      
    } catch (error) {
      console.error('[Index] 创建单打循环赛失败:', error);
      wx.showToast({ title: '创建失败', icon: 'none' });
      this.setData({ isCreating: false });
    }
  },

  /**
   * 创建双打淘汰赛
   */
  goToDoubleElimination(type) {
    if (this.data.isCreating) return; // 防止重复点击
    
    const userInfo = getApp().globalData.userInfo;
    if (!userInfo) {
      wx.showToast({ title: '请先登录', icon: 'none' });
      return;
    }
    
    this.setData({ isCreating: true });
    
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      // 1. 创建新比赛数据
      const now = new Date();
      const mm = (now.getMonth() + 1).toString().padStart(2, '0');
      const dd = now.getDate().toString().padStart(2, '0');
      const defaultTitle = `双打淘汰赛 | ${mm}-${dd}发布`;
      
      // 创建新比赛对象，复制RaceModel的所有属性
      const newRace = {};
      for (let key in RaceModel) {
        if (RaceModel.hasOwnProperty(key)) {
          newRace[key] = RaceModel[key];
        }
      }
      
      // 设置新比赛的属性
      newRace.id = this.generateId();
      newRace._id = this.generateId(); // 同时设置 _id 字段
      newRace.title = defaultTitle;
      newRace.dateStr = '';
      newRace.creator = userInfo;
      newRace.createdAt = now.toISOString();
      newRace.status = '报名中';
      newRace.type = type;
      newRace.courtCount = 1;
      newRace.maxPlayers = 8; // 双打淘汰赛默认8人（4对）
      newRace.signupList = [];
      newRace.gameList = [];
      
      // 2. 使用 localDataManager 保存到本地存储
      localDataManager.saveRace(newRace);
      
      // 3. 更新页面数据
      this.setData({ 
        isCreating: false 
      });
      
      // 4. 跳转到双打淘汰赛页面
      wx.navigateTo({
        url: `/pages/doubleElimination/doubleElimination?id=${newRace.id}`
      });
      
      wx.showToast({ title: '创建成功', icon: 'success' });
      
    } catch (error) {
      console.error('[Index] 创建双打淘汰赛失败:', error);
      wx.showToast({ title: '创建失败', icon: 'none' });
      this.setData({ isCreating: false });
    }
  },

  /**
   * 生成唯一ID
   */
  generateId() {
    return Date.now().toString(36) + Math.random().toString(36).substr(2);
  },
  
  /**
   * 导出数据
   */
  exportData() {
    try {
      // 引入本地数据管理器
      const localDataManager = require('../../utils/localDataManager.js');
      
      const exportData = {
        raceList: localDataManager.getAllRaces(),
        signupList: localDataManager.getAllSignups(),
        settings: wx.getStorageSync('settings') || {},
        userInfo: wx.getStorageSync('userInfo') || null,
        exportTime: new Date().toISOString()
      };
      
      const jsonString = JSON.stringify(exportData, null, 2);
      
      // 复制到剪贴板
      wx.setClipboardData({
        data: jsonString,
        success: () => {
          wx.showToast({ title: '数据已复制到剪贴板', icon: 'success' });
        }
      });
      
      console.log('[Index] 数据导出完成');
      
    } catch (error) {
      console.error('[Index] 导出数据失败:', error);
      wx.showToast({ title: '导出失败', icon: 'none' });
    }
  },

  /**
   * 清理数据
   */
  clearData() {
    wx.showModal({
      title: '确认清空',
      content: '确定要清空所有数据吗？此操作不可恢复！',
      success: (res) => {
        if (res.confirm) {
          try {
            // 引入本地数据管理器
            const localDataManager = require('../../utils/localDataManager.js');
            
            // 清空所有数据
            localDataManager.clearAllData();
            
            // 清空用户信息
            wx.removeStorageSync('userInfo');
            // 注意：不再清空badminton_users，以保留用户注册信息
            // 如果需要清空用户注册信息，请手动取消下面的注释
            // wx.removeStorageSync('badminton_users');
            
            // 重置页面数据
            this.setData({
              raceList: [],
              signupList: [],
              userInfo: null
            });
            
            wx.showToast({ title: '数据已清空', icon: 'success' });
            
            // 重新显示数据统计
            this.showDataStats();
            
          } catch (error) {
            console.error('清空数据失败:', error);
            wx.showToast({ title: '清空失败', icon: 'none' });
          }
        }
      }
    });
  },


});
